In conventional environments for fixed-point algorithm development, a user may have a number of options regarding how the precision of fixed-point numbers is handled for arithmetic operations. These options may be designated as “full precision” and “specify precision.” With the “full precision” option, a computational tool automatically calculates how many digits are needed to retain full precision of the result of the operation and uses a word length that accommodates the number of digits needed to retain full precision of the result of the operation. The minimum word length and radix point of the result of the operation are automatically determined so that no loss of precision or overflow will occur. This level of specification minimizes the need for the user to specify a multitude of changing attributes when emulating calculation of a fixed-point arithmetic operation on a particular machine but often leads to attributes that are not realizable on the emulated machine.
With the “specify precision” option, a word length and radix point for results of fixed-point arithmetic operations are specified by the user. This level of specification typically allows the user to exactly emulate calculation of a fixed-point arithmetic operation on a particular machine, but may place a burden on the user to calculate all attributes, even where the attributes are subject to frequent change.
Unfortunately, conventional environments lack a method for specifying any level of specification between full specification by the user and full precision by the computational tool. Additionally, conventional simulation environments typically lack a method for relieving the burden on the user of specifying all attributes without requiring full precision by a computational tool, which may result in attributes that are not realizable on a given architecture.
In addition, prior environments allocate superfluous space for performing a series of arithmetic operations in a fixed-point algorithm environment. For example, when a series of arithmetic operations, such as a series of additions, is performed, conventional environments for fixed-point algorithm development add one digit to a word holding the result of the series of arithmetic operations for each iteration in the series. Therefore, an addition of two single digit numbers, such as 8 and 9, would allocate a maximum number of digits (two) for storing the first result (17). If another operation were performed on that sum, for example the addition of another single digit number, such as 6, to the first result (17), a prior environment would allocate another whole digit to hold the resulting second result (23), even though only two digits would be needed. When another operation, for example, the addition of another single digit number, such as 8, is performed on the second result (23) from the previous iteration, prior environments would add another whole digit for the result, resulting in a word length comprising four digits to hold the resulting third result (31), even though still only two digits would be needed. Therefore, prior limited computer environments provide an inefficient use of hardware resources.